#include "reg_mod_pago_proveedores.h"
#include "ui_reg_mod_pago_proveedores.h"
#define CREDITO "crédito"
#define CONTADO "contado"
#define PENDIENTE "pendiente"
#define REALIZADA "realizada"
#define EFECTIVO "e"
#define TARJETACREDITO "tc"
#define TARJETADEBITO "td"
#define CHEQUE "c"

Reg_mod_pago_proveedores::Reg_mod_pago_proveedores(QWidget *parent, Compra *compra, QList<Detalle_compra*> *detalleList) :
    QDialog(parent),
    ui(new Ui::Reg_mod_pago_proveedores)
{
    ui->setupUi(this);
    ui->efectivoGroupBox->setEnabled(false);
    ui->tarjetaGroupBox->setEnabled(false);
    ui->chequeGroupBox->setEnabled(false);
    this->compraVarLocal = compra;
    this->detalleListLocal = detalleList;

    ui->totalLabel->setText(QString::number(this->compraVarLocal->getTotal()));

    ui->proveedorLabel->setText(compraVarLocal->getProveedor()->getNombre());

    ui->bancoComboBox->addItem("");
    ui->marcaTarjetacomboBox->addItem("");

    ui->dateEdit->setDate(QDate::currentDate());

    //Validaciones de campos
    validatorNum = new QIntValidator(1, 999999999);
    validatorString = new QRegExpValidator(QRegExp("[^0-9]{50}"),this);

    ui->importeChequeLineEdit->setValidator(validatorNum);
    ui->importeEfectivoLineEdit->setValidator(validatorNum);
    ui->importeTarjetaLineEdit->setValidator(validatorNum);
    ui->numeroTarjetaLineEdit->setValidator(validatorNum);
    ui->numeroChequeLineEdit->setValidator(validatorNum);

    QDjangoQuerySet<banco_cheque> bancosLista;
    QDjangoQuerySet<marca_tarjeta> marcasLista;
    QDjangoQuerySet<Cuentas_por_pagar> cuentas;
    QDjangoQuerySet<pago_proveedor> pagos;
    Cuentas_por_pagar *cuenta = new Cuentas_por_pagar();

    if(bancosLista.count() != 0 && marcasLista.count() != 0
            && cuentas.count() != 0 && pagos.count() != 0)
    {

        //se carga combobox de bancos
        foreach (const banco_cheque &banco, bancosLista)
        {
            if (banco.getId_banco() != 0)
            {
                ui->bancoComboBox->addItem(banco.getNombre());
            }
        }

        //se carga combobox de marcas de tarjetas
        foreach (const marca_tarjeta &marca, marcasLista)
        {
            if (marca.getId_marca_tarjeta() != 0)
            {
                ui->marcaTarjetacomboBox->addItem(marca.getNombre());
            }
        }
      }

        //Si la factura de la compra es a crédito se muestran los datos del pago a crédito.
        if (compraVarLocal->getTipo_pago() == CREDITO)
        {
            ui->creditoGroupBox->setVisible(true);
            cuenta = cuentas.filter(QDjangoWhere("compra_id", QDjangoWhere::Equals, compraVarLocal->getId_compra())).at(0);
            ui->importeCuotaLabel->setText(QString::number(cuenta->getMonto_cuota()));
            ui->abonadoLabel->setText(QString::number(cuenta->getMonto_abonado()));
            ui->pendienteLabel->setText(QString::number(cuenta->getMonto_pendiente()));
            ui->abonarCreditoLabel->setText(QString::number(cuenta->getMonto_siguiente()));
            ui->cuotaActualLabel->setText(QString::number(cuenta->getNumero_cuota_actual()));
            ui->cuotasLabel->setText(QString::number(cuenta->getNumero_cuotas()));
        }
        else
        {
            ui->creditoGroupBox->setVisible(false);
        }

        //Si la compra ya se realizó solo se visualiza el pago pero ya no se puede editar.
        if (compraVarLocal->getEstado() == REALIZADA && compra->getTipo_pago() == CONTADO)
        {
            ui->registarPagoPushButton->setVisible(false);
            ui->cancelarPagoPushButton->setText("Atrás");
            ui->efectivoCheckBox->setEnabled(false);
            ui->efectivoGroupBox->setEnabled(false);
            ui->chequeCheckBox->setEnabled(false);
            ui->chequeGroupBox->setEnabled(false);
            ui->tarjetaCheckBox->setEnabled(false);
            ui->tarjetaGroupBox->setEnabled(false);
            ui->dateEdit->setEnabled(false);
            ui->creditoGroupBox->setEnabled(false);
            ui->verMontoAbonarPushButton->setEnabled(false);
            ui->abonarGroupBox->setVisible(false);

            pagos = pagos.filter(QDjangoWhere("compra_id", QDjangoWhere::Equals, compraVarLocal->getId_compra()));

            foreach (const pago_proveedor &pago, pagos)
            {
                if(pago.getMedio_pago() == EFECTIVO)
                {
                    ui->efectivoCheckBox->setChecked(true);
                    ui->importeEfectivoLineEdit->setText(QString::number(pago.getMonto()));
                }

                if(pago.getMedio_pago() == TARJETACREDITO)
                {
                    ui->tarjetaCheckBox->setChecked(true);
                    ui->importeTarjetaLineEdit->setText(QString::number(pago.getMonto()));
                    ui->TcRadioButton->setChecked(true);
                    ui->marcaTarjetacomboBox->setCurrentText(pago.getTarjeta()->getMarca()->getNombre());
                    ui->numeroTarjetaLineEdit->setText(QString::number(pago.getTarjeta()->getNumero()));
                }

                if(pago.getMedio_pago() == TARJETADEBITO)
                {
                    ui->tarjetaCheckBox->setChecked(true);
                    ui->importeTarjetaLineEdit->setText(QString::number(pago.getMonto()));
                    ui->TdRadioButton->setChecked(true);
                    ui->marcaTarjetacomboBox->setCurrentText(pago.getTarjeta()->getMarca()->getNombre());
                    ui->numeroTarjetaLineEdit->setText(QString::number(pago.getTarjeta()->getNumero()));
                }

                if(pago.getMedio_pago() == CHEQUE)
                {
                    ui->chequeCheckBox->setChecked(true);
                    ui->importeChequeLineEdit->setText(QString::number(pago.getMonto()));
                    ui->bancoComboBox->setCurrentText(pago.getCheque()->getBanco()->getNombre());
                    ui->fechaEmisiondateEdit->setDate(pago.getCheque()->getFecha_emision());
                    ui->numeroChequeLineEdit->setText(pago.getCheque()->getNumero_cheque());
                }

            }
            ui->dateEdit->setDate(pagos.at(0)->getFecha());
            delete cuenta;
        }
    }
//}

Reg_mod_pago_proveedores::~Reg_mod_pago_proveedores()
{
    delete ui;
}

void Reg_mod_pago_proveedores::on_efectivoCheckBox_clicked()
{
    if(ui->efectivoCheckBox->isChecked())
    {
        ui->efectivoGroupBox->setEnabled(true);
    }
    else
    {
        ui->efectivoGroupBox->setEnabled(false);
    }
}

void Reg_mod_pago_proveedores::on_tarjetaCheckBox_clicked()
{
    if(ui->tarjetaCheckBox->isChecked())
    {
        ui->tarjetaGroupBox->setEnabled(true);
    }
    else
    {
        ui->tarjetaGroupBox->setEnabled(false);
    }
}

void Reg_mod_pago_proveedores::on_chequeCheckBox_clicked()
{
    if(ui->chequeCheckBox->isChecked())
    {
        ui->fechaEmisiondateEdit->setDate(QDate::currentDate());
        ui->chequeGroupBox->setEnabled(true);
    }
    else
    {
        ui->fechaEmisiondateEdit->setDate(QDate(00,00,00));
        ui->chequeGroupBox->setEnabled(false);
    }
}

void Reg_mod_pago_proveedores::on_registarPagoPushButton_clicked()
{
    int b = 0;
    if ((ui->efectivoCheckBox->isChecked() && ui->importeEfectivoLineEdit->text().isEmpty())
            || (ui->chequeCheckBox->isChecked() && (ui->importeChequeLineEdit->text().isEmpty()
            || (ui->numeroChequeLineEdit->text().isEmpty() || ui->bancoComboBox->currentText() == "")))
            || (ui->tarjetaCheckBox->isChecked() && (ui->importeTarjetaLineEdit->text().isEmpty()
            || (!ui->TcRadioButton->isChecked() && !ui->TdRadioButton->isChecked())
            || ui->numeroTarjetaLineEdit->text().isEmpty()
            || ui->marcaTarjetacomboBox->currentText() == "")))
    {
        cuadroMensaje("Campos obligatorios sin completar", "Debe completar todos los campos del/los medio/s de pago seleccionados"
                      , "error");
        b = 1;
    }

    if (!ui->efectivoCheckBox->isChecked() && !ui->tarjetaCheckBox->isChecked() && !ui->chequeCheckBox->isChecked())
    {
        cuadroMensaje("Ningún medio de pago seleccionado", "Debe seleccionar algún medio de pago para poder continuar"
                      , "error");
        b = 1;
    }

    if (b == 0)
    {
        pago_proveedor *pagoEfectivo = new pago_proveedor();
        pago_proveedor *pagoCheque = new pago_proveedor();
        pago_proveedor *pagoTarjeta = new pago_proveedor();
        Cheque *cheque = new Cheque();
        Tarjeta *tarjeta = new Tarjeta();

        banco_cheque *banco = new banco_cheque();
        marca_tarjeta *marca = new marca_tarjeta();
        Cuentas_por_pagar *cuenta = new Cuentas_por_pagar();

        QDjangoQuerySet<marca_tarjeta> marcs;
        QDjangoQuerySet<banco_cheque> bancs;
        QDjangoQuerySet<Tarjeta> tarjs;
        QDjangoQuerySet<Cheque> chqs;
        QDjangoQuerySet<Cuentas_por_pagar> cuentas;

        if(marcs.count() != 0 && bancs.count() != 0 && tarjs.count() != 0
                && chqs.count() != 0 && cuentas.count() != 0)
        {
            //ACUMULA EL IMPORTE A PAGAR
            double acumulado = 0;

            QSqlQuery query;
            query.exec("select coalesce(max(numero_pago)+1,1) from pago_proveedor");
            int maxNumeroPago;
            while (query.next())
            {
                maxNumeroPago = query.value(0).toInt();
            }

            // Pago en efectivo
            if (ui->efectivoCheckBox->isChecked())
            {
                if (ui->importeEfectivoLineEdit->text().toDouble() > ui->totalLabel->text().toDouble())
                {
                    ;
                }
                else
                {

                    pagoEfectivo->setCompra(compraVarLocal);
                    pagoEfectivo->setMedio_pago("e");
                    pagoEfectivo->setFecha(ui->dateEdit->date());
                    pagoEfectivo->setMonto(ui->importeEfectivoLineEdit->text().toDouble());

                    query.exec("select coalesce(max(id_pago),0) from pago_proveedor");
                    int maxId;
                    while (query.next())
                    {
                        maxId = query.value(0).toInt();
                    }
                    pagoEfectivo->setId_pago(maxId+1);
                    pagoEfectivo->setNumero_pago(maxNumeroPago);
                }
                acumulado = acumulado + ui->importeEfectivoLineEdit->text().toDouble();
            }

            // Pago en tarjeta
            if (ui->tarjetaCheckBox->isChecked())
            {
                if (ui->importeTarjetaLineEdit->text().toDouble() > ui->totalLabel->text().toDouble())
                {
                    ;
                }
                else
                {

                    pagoTarjeta->setCompra(compraVarLocal);

                    // tarjeta de crédito
                    if (ui->TcRadioButton->isChecked())
                    {
                        pagoTarjeta->setMedio_pago("tc");
                    }

                    // tarjeta de débito
                    if (ui->TdRadioButton->isChecked())
                    {
                        pagoTarjeta->setMedio_pago("td");
                    }

                    query.exec("select coalesce(max(id_pago),0) from pago_proveedor");
                    int maxId;
                    while (query.next())
                    {
                        maxId = query.value(0).toInt();
                    }
                    pagoTarjeta->setId_pago(maxId);
                    pagoTarjeta->setNumero_pago(maxNumeroPago);

                    pagoTarjeta->setMonto(ui->importeTarjetaLineEdit->text().toDouble());


                    marca = marcs.filter(QDjangoWhere("nombre", QDjangoWhere::Equals, ui->marcaTarjetacomboBox->currentText())).at(0);
                    tarjeta->setMarca(marca);
                    tarjeta->setTipo(pagoTarjeta->getMedio_pago());
                    tarjeta->setNumero(ui->numeroTarjetaLineEdit->text().toInt());

                    query.exec("select coalesce(max(id_tarjeta),0) from tarjeta");
                    int maxIdTarjeta;
                    while (query.next())
                    {
                        maxIdTarjeta = query.value(0).toInt();
                    }

                    tarjeta->setId_tarjeta(maxIdTarjeta + 1);

                    pagoTarjeta->setTarjeta(tarjeta);
                    pagoTarjeta->setMonto(ui->importeTarjetaLineEdit->text().toDouble());
                    pagoTarjeta->setFecha(ui->dateEdit->date());
                }

                acumulado = acumulado + ui->importeTarjetaLineEdit->text().toDouble();
            }

            // Pago en cheque
            if (ui->chequeCheckBox->isChecked())
            {
                pagoCheque->setCompra(compraVarLocal);

                if (ui->importeChequeLineEdit->text().toDouble() > ui->totalLabel->text().toDouble())
                {
                    ;
                }
                else
                {
                    pagoCheque->setMedio_pago("c");
                    pagoCheque->setMonto(ui->importeTarjetaLineEdit->text().toDouble());

                    query.exec("select coalesce(max(id_pago),0) from pago_proveedor");
                    int maxId;
                    while (query.next())
                    {
                        maxId = query.value(0).toInt();
                    }

                    pagoCheque->setId_pago(maxId);
                    pagoCheque->setNumero_pago(maxNumeroPago);

                    banco = bancs.filter(QDjangoWhere("nombre", QDjangoWhere::Equals, ui->bancoComboBox->currentText())).at(0);

                    cheque->setBanco(banco);
                    cheque->setEmisor(compraVarLocal->getProveedor()->getNombre());
                    cheque->setReceptor("Diaz Gill");
                    cheque->setNumero_cheque(ui->numeroChequeLineEdit->text());
                    cheque->setFecha_emision(ui->fechaEmisiondateEdit->date());
                    cheque->setFecha_cobro(ui->fechaEmisiondateEdit->date());

                    pagoCheque->setMonto(ui->importeChequeLineEdit->text().toDouble());
                    pagoCheque->setFecha(ui->dateEdit->date());

                    query.exec("select coalesce(max(id_cheque),0) from cheque");
                    int maxIdCheque;
                    while (query.next())
                    {
                        maxIdCheque = query.value(0).toInt();
                    }
                    cheque->setId_cheque(maxIdCheque + 1);

                    pagoCheque->setCheque(cheque);
                    delete banco;
                }

                acumulado = acumulado + ui->importeChequeLineEdit->text().toDouble();


            }

            int aux = 0;
            if (acumulado > ui->totalLabel->text().toDouble())
            {
                cuadroMensaje("Monto mayor al total de la compra", "El monto a pagar es mayor al importe de la compra", "error");
                aux = 1;
            }

            if (acumulado < ui->totalLabel->text().toDouble())
            {

                if ((compraVarLocal->getTipo_pago() == CREDITO  && acumulado < ui->abonarCreditoLabel->text().toDouble())
                        || compraVarLocal->getTipo_pago() == CONTADO)
                {
                    cuadroMensaje("Monto menor al importe a abonar en este pago", "El monto a pagar es menor al importe.", "error");
                    aux = 1;
                }
            }

            if (aux == 0)
            {
                cuenta = cuentas.filter(QDjangoWhere("compra_id", QDjangoWhere::Equals, compraVarLocal->getId_compra())).at(0);
                int x = 0;
                if (compraVarLocal->getTipo_pago() == CREDITO)
                {
                    //Si el monto pendiente es mayor a lo abonado más lo que se va a pagar ahora
                    if(cuenta->getMonto_pendiente() > cuenta->getMonto_abonado() + acumulado)
                    {
                        compraVarLocal->setEstado(PENDIENTE);

                        //actualizamos la cuenta a pagar
                        double montoAbonado = acumulado + cuenta->getMonto_abonado();
                        double montoPendiente = compraVarLocal->getTotal() - montoAbonado;
                        cuenta->setMonto_abonado(montoAbonado);
                        cuenta->setMonto_pendiente(montoPendiente);

                        // Si paga por adelantado
                        if (acumulado > cuenta->getMonto_siguiente())
                        {
                            double montoSiguiente;

                            if (fmod(acumulado, cuenta->getMonto_cuota()) != 0)
                            {
                                montoSiguiente = /*acumulado - cuenta->getMonto_siguiente();*/montoPendiente;
                                cuenta->setNumero_cuota_actual(cuenta->getNumero_cuota_actual() + 1);
                            }
                            else
                            {
                                int cantCuotas = acumulado / cuenta->getMonto_cuota();
                                cuenta->setNumero_cuota_actual(cuenta->getNumero_cuota_actual() + cantCuotas);
                                montoSiguiente = cuenta->getMonto_cuota();
                            }

                            cuenta->setMonto_siguiente(montoSiguiente);
                        }

                        // si ya completa el pago de lo que debía abonar en esa cuota
                        if (acumulado == cuenta->getMonto_siguiente())
                        {

                            double montoSiguiente = cuenta->getMonto_cuota();
                            cuenta->setMonto_siguiente(montoSiguiente);
                            cuenta->setNumero_cuota_actual(cuenta->getNumero_cuota_actual() + 1);
                        }
                    }
                    else if (cuenta->getMonto_pendiente() == /*cuenta->getMonto_abonado()*/acumulado)
                    {
                        compraVarLocal->setEstado(REALIZADA);

                        //actualizamos la cuenta a pagar
                        double montoAbonado = acumulado + cuenta->getMonto_abonado();
                        double montoPendiente = 0;
                        cuenta->setMonto_siguiente(0);
                        cuenta->setMonto_abonado(montoAbonado);
                        cuenta->setMonto_pendiente(montoPendiente);
                        cuenta->setNumero_cuota_actual(cuenta->getNumero_cuotas());
                    }
                    else
                    {
                        cuadroMensaje("Verifique monto ingresado", "Monto mayor a monto pendiente de pago", "error");
                        this->compraVarLocal->setEstado(PENDIENTE);
                        x=1;
                    }
                }
                else if (compraVarLocal->getTipo_pago() == CONTADO)
                {
                    this->compraVarLocal->setEstado(REALIZADA);
                }

                // guardamos la compra en la bd con el estado correspondiente
                this->compraVarLocal->save();

            if (x==0)
            {
                // guardamos la cuenta en caso de existir
                if (cuenta != NULL)
                {
                    cuenta->save();
                }

                if (ui->efectivoCheckBox->isChecked())
                {
                    //                QDjangoQuerySet<banco_cheque> bancs;
                    banco_cheque *ban = new banco_cheque();
                    ban = bancs.filter(QDjangoWhere("id_banco", QDjangoWhere::Equals, 0)).at(0);
                    if (ban == NULL)
                    {
                        ban = new banco_cheque();
                        ban->setId_banco(0);
                        ban->save();
                    }

                    Cheque *cheq = new Cheque();
                    cheq = chqs.filter(QDjangoWhere("id_cheque", QDjangoWhere::Equals, 0)).at(0);
                    if (cheq == NULL)
                    {
                        cheq = new Cheque();
                        cheq->setId_cheque(0);
                        cheq->setBanco(ban);
                        cheq->setFecha_cobro(ui->dateEdit->date());
                        cheq->setFecha_emision(ui->dateEdit->date());
                        cheq->save();
                    }

                    //                QDjangoQuerySet<marca_tarjeta> marcs;
                    marca_tarjeta *mar = new marca_tarjeta();
                    mar = marcs.filter(QDjangoWhere("id_marca_tarjeta", QDjangoWhere::Equals, 0)).at(0);
                    if (mar == NULL)
                    {
                        mar = new marca_tarjeta();
                        mar->setId_marca_tarjeta(0);
                        mar->save();
                    }

                    Tarjeta *tar = new Tarjeta();
                    tar = tarjs.filter(QDjangoWhere("id_tarjeta", QDjangoWhere::Equals, 0)).at(0);
                    if (tar == NULL)
                    {
                        tar = new Tarjeta();
                        tar->setId_tarjeta(0);
                        tar->setMarca(mar);
                        tar->save();
                    }

                    pagoEfectivo->setCheque(cheq);
                    pagoEfectivo->setTarjeta(tar);

                    pagoEfectivo->save();

                    delete mar;
                    delete ban;
                    delete tar;
                    delete cheq;
                }

                if (ui->chequeCheckBox->isChecked())
                {
                    //                QDjangoQuerySet<marca_tarjeta> marcs;
                    marca_tarjeta *mar = new marca_tarjeta();
                    mar = marcs.filter(QDjangoWhere("id_marca_tarjeta", QDjangoWhere::Equals, 0)).at(0);
                    if (mar == NULL)
                    {
                        mar = new marca_tarjeta();
                        mar->setId_marca_tarjeta(0);
                        mar->save();
                    }

                    //                QDjangoQuerySet<Tarjeta> tarjs;
                    Tarjeta *tar = new Tarjeta();
                    tar = tarjs.filter(QDjangoWhere("id_tarjeta", QDjangoWhere::Equals, 0)).at(0);
                    if (tar == NULL)
                    {
                        tar = new Tarjeta();
                        tar->setId_tarjeta(0);
                        tar->setMarca(mar);
                        tar->save();
                    }

                    pagoCheque->setTarjeta(tar);

                    cheque->save();
                    pagoCheque->setCheque(cheque);
                    pagoCheque->save();

                    delete mar;
                    delete tar;
                }

                if (ui->tarjetaCheckBox->isChecked())
                {
                    //                QDjangoQuerySet<banco_cheque> bancs;
                    banco_cheque *ban = new banco_cheque();
                    ban = bancs.filter(QDjangoWhere("id_banco", QDjangoWhere::Equals, 0)).at(0);
                    if (ban == NULL)
                    {
                        ban = new banco_cheque();
                        ban->setId_banco(0);
                        ban->save();
                    }

                    //                QDjangoQuerySet<Cheque> chqs;
                    Cheque *cheq = new Cheque();
                    cheq = chqs.filter(QDjangoWhere("id_cheque", QDjangoWhere::Equals, 0)).at(0);
                    if (cheq == NULL)
                    {
                        cheq = new Cheque();
                        cheq->setId_cheque(0);
                        cheq->setBanco(ban);
                        cheq->setFecha_cobro(ui->dateEdit->date());
                        cheq->setFecha_emision(ui->dateEdit->date());
                        cheq->save();
                    }

                    pagoTarjeta->setCheque(cheq);

                    tarjeta->save();
                    pagoTarjeta->setTarjeta(tarjeta);
                    pagoTarjeta->save();

                    delete ban;
                    delete cheq;
                }

                Insumo *insumo = new Insumo();
                // recorremos la lista de detalles de la compra
                for (int i = 0; i<=detalleListLocal->count()-1; i++)
                {
                    //guardamos o actualizamos el detalle en bd.
                    detalleListLocal->at(i)->save();

                    query.clear();
                    query.exec("select insumo_proveedor_id from detalle_compra where id_detalle_compra = '" +  QString::number(detalleListLocal->at(i)->getId_detalle_compra()) + "'");
                    qDebug()<<query.lastQuery();
                    int id_insProv = 0;
                    while(query.next())
                    {
                        id_insProv = query.value(0).toInt();
                    }

                    query.clear();
                    query.exec("select insumo_id from insumo_proveedor where id_insumo_proveedor = '" + QString::number(id_insProv) + "'");
                    qDebug()<<query.lastQuery();
                    int id_ins = 0;
                    while(query.next())
                    {
                        id_ins = query.value(0).toInt();
                    }

                    if (compraVarLocal->getTipo_pago() == CONTADO)
                    {
                        //actualizamos el stock del insumo del detalle y la fecha de ultima compra.
                        query.clear();
                        query.exec("update insumo set stock_actual= stock_actual + "
                                   + QString::number(detalleListLocal->at(i)->getCantidad())
                                   + ", ultima_compra= '" + QString::number(ui->dateEdit->date().day())
                                   + "-" + QString::number(ui->dateEdit->date().month()) + "-"
                                   + QString::number(ui->dateEdit->date().year())
                                   + "' where idinsumo = '" + QString::number(id_ins) + "'");
                    }
                }
                delete insumo;

                cuadroMensaje("Éxito", "Pago registrado");
                this->close();
            }

                //delete banco;
               // delete marca;
//                delete pagoCheque;
//                delete pagoEfectivo;
//                delete pagoTarjeta;
//                delete cheque;
//                delete tarjeta;
            }
        }
    }
}


void Reg_mod_pago_proveedores::on_cancelarPagoPushButton_clicked()
{
    this->close();
}

void Reg_mod_pago_proveedores::on_verMontoAbonarPushButton_clicked()
{
    double total = 0;
    if (ui->chequeCheckBox->isChecked())
    {
        total = total + ui->importeChequeLineEdit->text().toDouble();
    }

    if (ui->tarjetaCheckBox->isChecked())
    {
        total = total + ui->importeTarjetaLineEdit->text().toDouble();
    }

    if (ui->efectivoCheckBox->isChecked())
    {
        total = total +ui->importeEfectivoLineEdit->text().toDouble();
    }

    ui->montoAbonarLabel->setText(QString::number(total));
}

void Reg_mod_pago_proveedores::on_addMarcaPushButton_clicked()
{
    Reg_marca_tarjeta *reg = new Reg_marca_tarjeta();
    reg->exec();
     delete reg;

    //se carga combobox de marcas de tarjetas
    QDjangoQuerySet<marca_tarjeta> marcasLista;

    if(marcasLista.count() != 0 && marcasLista.count() != ui->marcaTarjetacomboBox->count() - 1)
    {
        ui->marcaTarjetacomboBox->addItem(marcasLista.at(marcasLista.count()-1)->getNombre());
    }
}

void Reg_mod_pago_proveedores::on_addBancopushButton_clicked()
{
    reg_banco *reg = new reg_banco();

    reg->exec();

    delete reg;

    //se carga combobox de bancos cheque.
    QDjangoQuerySet<banco_cheque> bancosLista;

    if(bancosLista.count() != 0 && bancosLista.count() != ui->bancoComboBox->count() - 1)
    {
        ui->bancoComboBox->addItem(bancosLista.at(bancosLista.count()-1)->getNombre());
    }

    //    delete reg;
}
#undef CONTADO
#undef CREDITO
#undef PENDIENTE
#undef REALIZADA
#undef TARJETACREDITO
#undef TARJETADEBITO
#undef CHEQUE
#undef EFECTIVO
